"use strict";
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
// https://www.bilibili.com/video/BV1Xy4y1v7S2/?p=16&spm_id_from=pageDriver&vd_source=0edc6e41570cd7a1d7dae6d34d5bd0b3
// 类和属性已经方法的定义和使用
var Person = /** @class */ (function () {
    function Person() {
        // 定义实例属性,直接通过实例进行访问
        this.name = "黄忠";
        this.age = 18;
        // 只读属性的属性
        this.idCard = 13579;
    }
    // 属性方法定义,这里定义不需要写function()
    Person.prototype.sayHello = function () {
        return "末将" + this.name + "今年" + this.age.toString();
    };
    // 类方法,也就是使用 static 定义的,可以认为是静态方法,只能用类名进行访问,而且类方法里面只能调用静态属性
    Person.watchTV = function () {
        // return this.name + "在看电视"
        return "我的地址是" + this.address;
    };
    // 定义静态属性,只能通过类进行访问
    Person.address = "南山区";
    return Person;
}());
var per = new Person();
console.log(per.name);
console.log(per.age);
// console.log(per.adderss) // 这里的静态属性不可以使用实例进行访问,只能使用类进行访问
console.log(Person.address);
per.name = "赵子龙";
console.log(per.name);
Person.address = "吴国";
console.log(Person.address);
console.log(per.idCard);
// per.idCard = 145  // 这里只读属性是不允许改变的
console.log(per.sayHello()); // 这里就可以直接通过实例来访问方法
console.log(Person.watchTV()); // 调用类方法,类方法也就只能调用静态属性
// 构造函数(感觉这个定义和c++差不多啊,搞的都是老一套了)
var Dog = /** @class */ (function () {
    function Dog() {
        this.name = "旺财";
        this.age = 2;
    }
    Dog.prototype.bark = function () {
        console.log('汪汪汪');
        // alert("ddd") // 这个ts编译不报错,但是编译成js以后无法运行
    };
    return Dog;
}());
var d1 = new Dog();
d1.bark();
// 这个时候定义类的时候创建属性就需要赋值
var Cat = /** @class */ (function () {
    function Cat() {
    }
    return Cat;
}());
var c1 = new Cat();
console.log(c1.name); // 这里没有赋值的时候直接log是 undefined
c1.name = "小喵";
console.log(c1.name); // 这里赋值以后就可以显示了
var Cat2 = /** @class */ (function () {
    // 构造函数
    function Cat2(n, a) {
        this.name = n;
        this.age = a;
    }
    return Cat2;
}());
var cc1 = new Cat2("大黄", 1); // 这里定义构造函数以后,new的时候就需要赋值了
console.log(cc1.name, cc1.age);
// -------------------- 继承的了解 --------------
var Animal = /** @class */ (function () {
    function Animal(n, a) {
        this.name = n;
        this.age = a;
    }
    Animal.prototype.sayHello = function () {
        console.log('动物在叫');
    };
    return Animal;
}());
// 这里 BigDog 继承 Animal 的类
var BigDog = /** @class */ (function (_super) {
    __extends(BigDog, _super);
    function BigDog() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    BigDog.prototype.sayHello = function () {
        // super.sayHello();
        console.log("汪汪汪");
    };
    return BigDog;
}(Animal));
var BigCat = /** @class */ (function (_super) {
    __extends(BigCat, _super);
    // 这里如果子类重写父类的构造函数,那么就必须调用父类的构造函数,否则会被替换掉,父类对于其他值的初始化不生效会导致出现问题
    function BigCat(n, a, s) {
        var _this = _super.call(this, n, a) || this; // 子类重写父类的构造函数,就必须调用父类的构造函数
        _this.address = s;
        return _this;
    }
    BigCat.prototype.sayHello = function () {
        // 这里调用子类的这个方法,如果没有的时候,就会调用父类的这个方法
        _super.prototype.sayHello.call(this);
    };
    return BigCat;
}(Animal));
// const b1 = new BigDog()
// b1.sayHello() // 这里继承以后,子类就可以调用父类的方法和属性
var b2 = new BigCat("小黑", 1, "狗窝");
console.log(b2.name, b2.age, b2.address);
// ------------------------------ 抽象类 ----------------------------------
// 抽象类, 上面在继承的时候,Animal 也可以被实例化进行使用,但是在开发中,通常不希望这样的父类被实例化,
// 所以可以使用 abstract 定义为抽象类,这样就让这个类不会被创建对象,只能被继承使用
var MoreAnimal = /** @class */ (function () {
    function MoreAnimal(n, a) {
        this.name = n;
        this.age = a;
    }
    MoreAnimal.prototype.sayHello = function () {
        console.log('动物在叫');
    };
    return MoreAnimal;
}());
var MoreDog = /** @class */ (function (_super) {
    __extends(MoreDog, _super);
    function MoreDog() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    // 这里必须实现父类定义的抽象方法
    MoreDog.prototype.sayKitty = function () {
        console.log("狗子在叫");
    };
    return MoreDog;
}(MoreAnimal));
var Corgi = /** @class */ (function (_super) {
    __extends(Corgi, _super);
    function Corgi() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    // 这里因为在爷爷类定义的抽象函数,在父类重写了,这里不会报错,这里如果不重写的话,实际上就是继承了父类的这个方法
    Corgi.prototype.sayKitty = function () {
        // super.sayKitty();
        console.log('柯基在叫');
    };
    return Corgi;
}(MoreDog));
var d2 = new MoreDog("田园犬", 1);
console.log(d2.name);
d2.sayHello(); // 这里虽然也可以调用抽象父类里面定义的构造函数和方法,但是通常我们不希望直接调用父类的方法
d2.sayKitty();
var d3 = new Corgi("毛毛", 2);
d3.sayKitty(); // 这里调用就是重写以后的方法
// 这样在定义类的时候,就必须有接口里面的属性和方法
var obj = {
    name: "张莎",
    age: 18,
    address: "fasdf" // 后面添加一个接口属性以后,这里也就需要补上这个属性
};
// 定义接口用 interface 而实现接口用的是 implement
var MyClass = /** @class */ (function () {
    function MyClass() {
    }
    MyClass.prototype.sayHello = function () {
    };
    return MyClass;
}());
// 3 属性的封装
// 背景,因为属性可以任意修改,会导致逻辑错误,例如说年龄改成 -3
var Book = /** @class */ (function () {
    function Book() {
    }
    return Book;
}());
// let cardList: GetSpecialAuthAppllyGroupList[{}]
// cardList = [{
//     staff_name: '',
//     date_range_start: '',
//     date_range_end: '',
//     apply_reason: ''
// }]
// 新建一个
// let params: GetSpecialAuthAppllyParam
// params.tag_ids = []
// params.apply_desc = ''
// params.group_list = cardList
//
//
//
// console.log("最后的参数", params)
var useGroup = /** @class */ (function () {
    // 构造函数初始化属性
    function useGroup(a, s, e, name) {
        this.apply_reason = a;
        this.date_range_start = s;
        this.date_range_end = e;
        this.staff_name = name;
    }
    return useGroup;
}());
var useParams = /** @class */ (function () {
    // 构造函数
    function useParams(a, g, t) {
        this.apply_desc = a;
        this.group_list = g;
        this.tag_ids = t;
    }
    return useParams;
}());
var groupList = new useGroup('', '', '', []);
console.log(groupList);
// 声明对象数组
var groupArr;
// 把对象数组初始化
groupArr = [];
// 把对象放到数组里面
groupArr.push(groupList);
console.log(groupArr);
var params = new useParams('', groupArr, []);
console.log("显示数据", params);
// 这里定义的接口和初始化对象使用,貌似不太好用,前端只是定义一个数据结构,并不想很复杂的用来做什么,
// 看  https://gitee.com/makunet/maku-admin.git 项目看不太懂,还是要学习一下基础,前端的东西也是很复杂的
// 类内属性私有化
var MyCar = /** @class */ (function () {
    function MyCar() {
    }
    MyCar.prototype.getOil = function () {
        return this._oil;
    };
    MyCar.prototype.setOil = function (o) {
        if (o > 0) {
            if (isNaN(this._oil)) {
                this._oil = o;
            }
            else {
                this._oil = this._oil + o;
            }
        }
    };
    return MyCar;
}());
var kk = new MyCar();
console.log(kk.getOil());
kk.setOil(1);
kk.setOil(-1); // 这里通过 set 方法设置加油不能为负数
kk.setOil(-2);
console.log(kk.getOil()); // 1
kk.setOil(5);
console.log(kk.getOil());
